/*
    i2c-dev.c - i2c-bus driver, char device interface  

    Copyright (C) 1995-97 Simon G. Vogl
    Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
   But I have used so much of his original code and ideas that it seems
   only fair to recognize him as co-author -- Frodo */

/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */

/* The devfs code is contributed by Philipp Matthias Hahn 
   <pmhahn@titan.lahn.de> */

/* $Id$ */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/smp_lock.h>
#ifdef CONFIG_DEVFS_FS
#include <linux/devfs_fs_kernel.h>
#endif
#include <linux/init.h>
#include <linux/i2c.h>
#include "i2c-dev.h"
#include <asm/uaccess.h>

/* If you want debugging uncomment: */
/* #define DEBUG */


/* struct file_operations changed too often in the 2.1 series for nice code */

static ssize_t i2cdev_read (struct file *file, char *buf, size_t count, 
                            loff_t *offset);
static ssize_t i2cdev_write (struct file *file, const char *buf, size_t count, 
                             loff_t *offset);

static int i2cdev_ioctl (struct inode *inode, struct file *file, 
                         unsigned int cmd, unsigned long arg);
static int i2cdev_open (struct inode *inode, struct file *file);

static int i2cdev_release (struct inode *inode, struct file *file);

static int i2cdev_attach_adapter(struct i2c_adapter *adap);
static int i2cdev_detach_client(struct i2c_client *client);

static struct file_operations i2cdev_fops = {
  .owner    = THIS_MODULE,
  .llseek   = no_llseek,
  .read   = i2cdev_read,
  .write    = i2cdev_write,
  .ioctl    = i2cdev_ioctl,
  .open   = i2cdev_open,
  .release  = i2cdev_release,
};

#define I2CDEV_ADAPS_MAX I2C_ADAP_MAX
static struct i2c_adapter *i2cdev_adaps[I2CDEV_ADAPS_MAX];
#ifdef CONFIG_DEVFS_FS
static devfs_handle_t devfs_i2c[I2CDEV_ADAPS_MAX];
static devfs_handle_t devfs_handle = NULL;
#endif

static struct i2c_driver i2cdev_driver = {
  .name   = "i2c-dev dummy driver",
  .id   = I2C_DRIVERID_I2CDEV,
  .flags    = I2C_DF_DUMMY,
  .attach_adapter = i2cdev_attach_adapter,
  .detach_client  = i2cdev_detach_client,
};

static struct i2c_client i2cdev_client_template = {
  .name   = "I2C /dev entry",
  .addr   = -1,
  .driver   = &i2cdev_driver,
};

static ssize_t i2cdev_read (struct file *file, char *buf, size_t count,
                            loff_t *offset)
{
  char *tmp;
  int ret;

#ifdef DEBUG
  struct inode *inode = file->f_dentry->d_inode;
#endif /* DEBUG */

  struct i2c_client *client = (struct i2c_client *)file->private_data;

  if (count > 8192)
    count = 8192;

  /* copy user space data to kernel space. */
  tmp = kmalloc(count,GFP_KERNEL);
  if (tmp==NULL)
    return -ENOMEM;

#ifdef DEBUG
  printk(KERN_DEBUG "i2c-dev.o: i2c-%d reading %d bytes.\n",minor(inode->i_rdev),
         count);
#endif

  ret = i2c_master_recv(client,tmp,count);
  if (ret >= 0)
    ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
  kfree(tmp);
  return ret;
}

static ssize_t i2cdev_write (struct file *file, const char *buf, size_t count,
                             loff_t *offset)
{
  int ret;
  char *tmp;
  struct i2c_client *client = (struct i2c_client *)file->private_data;

#ifdef DEBUG
  struct inode *inode = file->f_dentry->d_inode;
#endif /* DEBUG */

  if (count > 8192)
    count = 8192;

  /* copy user space data to kernel space. */
  tmp = kmalloc(count,GFP_KERNEL);
  if (tmp==NULL)
    return -ENOMEM;
  if (copy_from_user(tmp,buf,count)) {
    kfree(tmp);
    return -EFAULT;
  }

#ifdef DEBUG
  printk(KERN_DEBUG "i2c-dev.o: i2c-%d writing %d bytes.\n",minor(inode->i_rdev),
         count);
#endif
  ret = i2c_master_send(client,tmp,count);
  kfree(tmp);
  return ret;
}

int i2cdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, 
                  unsigned long arg)
{
  struct i2c_client *client = (struct i2c_client *)file->private_data;
  struct i2c_rdwr_ioctl_data rdwr_arg;
  struct i2c_smbus_ioctl_data data_arg;
  union i2c_smbus_data temp;
  struct i2c_msg *rdwr_pa;
  u8 **data_ptrs;
  int i,datasize,res;
  unsigned long funcs;

#ifdef DEBUG
  printk(KERN_DEBUG "i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n", 
         minor(inode->i_rdev),cmd, arg);
#endif /* DEBUG */

  switch ( cmd ) {
  case I2C_SLAVE:
  case I2C_SLAVE_FORCE:
    if ((arg > 0x3ff) || 
        (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
      return -EINVAL;
    if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter,arg))
      return -EBUSY;
    client->addr = arg;
    return 0;
  case I2C_TENBIT:
    if (arg)
      client->flags |= I2C_M_TEN;
    else
      client->flags &= ~I2C_M_TEN;
    return 0;
  case I2C_PEC:
    if (arg)
      client->flags |= I2C_CLIENT_PEC;
    else
      client->flags &= ~I2C_CLIENT_PEC;
    return 0;
  case I2C_FUNCS:
    funcs = i2c_get_functionality(client->adapter);
    return (copy_to_user((unsigned long *)arg,&funcs,
                         sizeof(unsigned long)))?-EFAULT:0;

  case I2C_RDWR:
    if (copy_from_user(&rdwr_arg, 
           (struct i2c_rdwr_ioctl_data *)arg, 
           sizeof(rdwr_arg)))
      return -EFAULT;

    /* Put an arbitrary limit on the number of messages that can
     * be sent at once */
    if (rdwr_arg.nmsgs > 42)
      return -EINVAL;
    
    rdwr_pa = (struct i2c_msg *)
      kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), 
      GFP_KERNEL);

    if (rdwr_pa == NULL) return -ENOMEM;

    if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
           rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
      kfree(rdwr_pa);
      return -EFAULT;
    }

    data_ptrs = (u8 **) kmalloc(rdwr_arg.nmsgs * sizeof(u8 *),
              GFP_KERNEL);
    if (data_ptrs == NULL) {
      kfree(rdwr_pa);
      return -ENOMEM;
    }

    res = 0;
    for( i=0; i<rdwr_arg.nmsgs; i++ )
    {
      /* Limit the size of the message to a sane amount;
       * and don't let length change either. */
      if ((rdwr_pa[i].len > 8192) ||
          (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
        res = -EINVAL;
        break;
      }
      data_ptrs[i] = rdwr_pa[i].buf;
      rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
      if(rdwr_pa[i].buf == NULL)
      {
        res = -ENOMEM;
        break;
      }
      if(copy_from_user(rdwr_pa[i].buf,
        data_ptrs[i],
        rdwr_pa[i].len))
      {
        ++i; /* Needs to be kfreed too */
        res = -EFAULT;
        break;
      }
    }
    if (res < 0) {
      int j;
      for (j = 0; j < i; ++j)
        kfree(rdwr_pa[j].buf);
      kfree(data_ptrs);
      kfree(rdwr_pa);
      return res;
    }

    res = i2c_transfer(client->adapter,
      rdwr_pa,
      rdwr_arg.nmsgs);
    while(i-- > 0)
    {
      if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD))
      {
        if(copy_to_user(
          data_ptrs[i],
          rdwr_pa[i].buf,
          rdwr_pa[i].len))
        {
          res = -EFAULT;
        }
      }
      kfree(rdwr_pa[i].buf);
    }
    kfree(data_ptrs);
    kfree(rdwr_pa);
    return res;

  case I2C_SMBUS:
    if (copy_from_user(&data_arg,
                       (struct i2c_smbus_ioctl_data *) arg,
                       sizeof(struct i2c_smbus_ioctl_data)))
      return -EFAULT;
    if ((data_arg.size != I2C_SMBUS_BYTE) && 
        (data_arg.size != I2C_SMBUS_QUICK) &&
        (data_arg.size != I2C_SMBUS_BYTE_DATA) && 
        (data_arg.size != I2C_SMBUS_WORD_DATA) &&
        (data_arg.size != I2C_SMBUS_PROC_CALL) &&
        (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
        (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
        (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
#ifdef DEBUG
      printk(KERN_DEBUG "i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.\n",
             data_arg.size);
#endif
      return -EINVAL;
    }
    /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1, 
       so the check is valid if size==I2C_SMBUS_QUICK too. */
    if ((data_arg.read_write != I2C_SMBUS_READ) && 
        (data_arg.read_write != I2C_SMBUS_WRITE)) {
#ifdef DEBUG
      printk(KERN_DEBUG "i2c-dev.o: read_write out of range (%x) in ioctl I2C_SMBUS.\n",
             data_arg.read_write);
#endif
      return -EINVAL;
    }

    /* Note that command values are always valid! */

    if ((data_arg.size == I2C_SMBUS_QUICK) ||
        ((data_arg.size == I2C_SMBUS_BYTE) && 
        (data_arg.read_write == I2C_SMBUS_WRITE)))
      /* These are special: we do not use data */
      return i2c_smbus_xfer(client->adapter, client->addr,
                            client->flags,
                            data_arg.read_write,
                            data_arg.command,
                            data_arg.size, NULL);

    if (data_arg.data == NULL) {
#ifdef DEBUG
      printk(KERN_DEBUG "i2c-dev.o: data is NULL pointer in ioctl I2C_SMBUS.\n");
#endif
      return -EINVAL;
    }

    if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
        (data_arg.size == I2C_SMBUS_BYTE))
      datasize = sizeof(data_arg.data->byte);
    else if ((data_arg.size == I2C_SMBUS_WORD_DATA) || 
             (data_arg.size == I2C_SMBUS_PROC_CALL))
      datasize = sizeof(data_arg.data->word);
    else /* size == smbus block, i2c block, or block proc. call */
      datasize = sizeof(data_arg.data->block);

    if ((data_arg.size == I2C_SMBUS_PROC_CALL) || 
        (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || 
        (data_arg.read_write == I2C_SMBUS_WRITE)) {
      if (copy_from_user(&temp, data_arg.data, datasize))
        return -EFAULT;
    }
    res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
          data_arg.read_write,
          data_arg.command,data_arg.size,&temp);
    if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) || 
                  (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || 
            (data_arg.read_write == I2C_SMBUS_READ))) {
      if (copy_to_user(data_arg.data, &temp, datasize))
        return -EFAULT;
    }
    return res;

  default:
    return i2c_control(client,cmd,arg);
  }
  return 0;
}

int i2cdev_open (struct inode *inode, struct file *file)
{
  unsigned int minor = minor(inode->i_rdev);
  struct i2c_client *client;

  if ((minor >= I2CDEV_ADAPS_MAX) || ! (i2cdev_adaps[minor])) {
#ifdef DEBUG
    printk(KERN_DEBUG "i2c-dev.o: Trying to open unattached adapter i2c-%d\n",
           minor);
#endif
    return -ENODEV;
  }

  /* Note that we here allocate a client for later use, but we will *not*
     register this client! Yes, this is safe. No, it is not very clean. */
  if(! (client = kmalloc(sizeof(struct i2c_client),GFP_KERNEL)))
    return -ENOMEM;
  memcpy(client,&i2cdev_client_template,sizeof(struct i2c_client));

  /* registered with adapter, passed as client to user */
  client->adapter = i2cdev_adaps[minor];
  file->private_data = client;

  if (client->adapter->inc_use)
    client->adapter->inc_use(client->adapter);

#ifdef DEBUG
  printk(KERN_DEBUG "i2c-dev.o: opened i2c-%d\n",minor);
#endif
  return 0;
}

static int i2cdev_release (struct inode *inode, struct file *file)
{
  struct i2c_client *client;
#ifdef DEBUG
  unsigned int minor = minor(inode->i_rdev);
#endif

  client = file->private_data;
  file->private_data = NULL;
  if (client->adapter->dec_use)
    client->adapter->dec_use(client->adapter);
  kfree(client);
#ifdef DEBUG
  printk(KERN_DEBUG "i2c-dev.o: Closed: i2c-%d\n", minor);
#endif
  return 0;
}

int i2cdev_attach_adapter(struct i2c_adapter *adap)
{
  int i;
  char name[8];

  if ((i = i2c_adapter_id(adap)) < 0) {
    printk(KERN_DEBUG "i2c-dev.o: Unknown adapter ?!?\n");
    return -ENODEV;
  }
  if (i >= I2CDEV_ADAPS_MAX) {
    printk(KERN_DEBUG "i2c-dev.o: Adapter number too large?!? (%d)\n",i);
    return -ENODEV;
  }

  sprintf (name, "%d", i);
  if (! i2cdev_adaps[i]) {
    i2cdev_adaps[i] = adap;
#ifdef CONFIG_DEVFS_FS
    devfs_i2c[i] = devfs_register (devfs_handle, name,
      DEVFS_FL_DEFAULT, I2C_MAJOR, i,
      S_IFCHR | S_IRUSR | S_IWUSR,
      &i2cdev_fops, adap);
#endif
    printk(KERN_DEBUG "i2c-dev.o: Registered '%s' as minor %d\n",adap->name,i);
  } else {
    /* This is actually a detach_adapter call! */
#ifdef CONFIG_DEVFS_FS
    devfs_unregister(devfs_i2c[i]);
#endif
    i2cdev_adaps[i] = NULL;
#ifdef DEBUG
    printk(KERN_DEBUG "i2c-dev.o: Adapter unregistered: %s\n",adap->name);
#endif
  }

  return 0;
}

int i2cdev_detach_client(struct i2c_client *client)
{
  return 0;
}

static int __init i2c_dev_init(void)
{
  int res;

  printk(KERN_INFO "i2c-dev.o: i2c /dev entries driver module version %s (%s)\n", I2C_VERSION, I2C_DATE);

#ifdef CONFIG_DEVFS_FS
  if (devfs_register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops)) {
#else
  if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) {
#endif
    printk(KERN_ERR "i2c-dev.o: unable to get major %d for i2c bus\n",
           I2C_MAJOR);
    return -EIO;
  }
#ifdef CONFIG_DEVFS_FS
  devfs_handle = devfs_mk_dir(NULL, "i2c", NULL);
#endif
  if ((res = i2c_add_driver(&i2cdev_driver))) {
    printk(KERN_ERR "i2c-dev.o: Driver registration failed, module not inserted.\n");
#ifdef CONFIG_DEVFS_FS
    devfs_unregister(devfs_handle);
#endif
    unregister_chrdev(I2C_MAJOR,"i2c");
    return res;
  }
  return 0;
}

static void __exit i2c_dev_exit(void)
{
  i2c_del_driver(&i2cdev_driver);
#ifdef CONFIG_DEVFS_FS
  devfs_unregister(devfs_handle);
#endif
  unregister_chrdev(I2C_MAJOR,"i2c");
}

EXPORT_NO_SYMBOLS;

MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and Simon G. Vogl <simon@tk.uni-linz.ac.at>");
MODULE_DESCRIPTION("I2C /dev entries driver");
MODULE_LICENSE("GPL");

module_init(i2c_dev_init);
module_exit(i2c_dev_exit);